/**
 * @file decision.js
 * @description AI决策辅助系统API接口
 * @created 2025-05-12
 */

import request from '@/utils/request'
import axios from 'axios'

// API密钥配置 - Dify API集成
const DECISION_API_KEY = 'app-pRGQbFwKawC85Ao1TUCG095w' // 更新为新的API密钥
const DECISION_API_SERVER = 'http://121.40.242.43/v1'

// 模拟模式开关 - 在API服务不可用时启用
export const USE_MOCK_DATA = true // 启用模拟数据模式
// 禁用自动降级到模拟数据
export const DISABLE_AUTO_FALLBACK = false // 允许自动降级

// 使用后端代理开关 - 避免跨域问题
const USE_BACKEND_PROXY = true

// 添加直接访问信息 - 用于调试
console.log('Dify API配置信息：', {
  api_key: DECISION_API_KEY,
  server_url: DECISION_API_SERVER,
  mock_mode: USE_MOCK_DATA,
  proxy_mode: USE_BACKEND_PROXY
});

/**
 * 验证Dify API密钥格式是否正确
 * @param {string} apiKey - 待验证的API密钥
 * @returns {Object} 验证结果
 */
function validateApiKey(apiKey) {
  if (!apiKey) {
    return {
      valid: false,
      message: 'API密钥不能为空'
    };
  }
  
  // Dify API密钥通常以app-开头，并且长度大约为30个字符
  if (!apiKey.startsWith('app-')) {
    return {
      valid: false,
      message: 'API密钥格式可能不正确，Dify API密钥通常以app-开头'
    };
  }
  
  if (apiKey.length < 25) {
    return {
      valid: false,
      message: 'API密钥长度可能不正确，通常应该有25个以上的字符'
    };
  }
  
  return {
    valid: true,
    message: 'API密钥格式正确'
  };
}

/**
 * 检查API服务器URL是否有效
 * @param {string} url - 服务器URL
 * @returns {Object} 检查结果
 */
function validateServerUrl(url) {
  if (!url) {
    return {
      valid: false,
      message: 'API服务器URL不能为空'
    };
  }
  
  try {
    new URL(url);
    return {
      valid: true,
      message: 'API服务器URL格式正确'
    };
  } catch (e) {
    return {
      valid: false,
      message: 'API服务器URL格式不正确: ' + e.message
    };
  }
}

// 验证配置
const apiKeyValidation = validateApiKey(DECISION_API_KEY);
const serverUrlValidation = validateServerUrl(DECISION_API_SERVER);

// 输出验证结果
console.log('Dify API密钥验证结果:', apiKeyValidation);
console.log('Dify API服务器验证结果:', serverUrlValidation);

/**
 * 调用Dify API
 * @param {Object} data - 请求参数
 * @param {string} data.query - 查询内容
 * @param {Object} data.inputs - 输入参数（可选）
 * @param {number|string} data.intent - 意图类型（可选，默认为5）
 *                               1-数据概览
 *                               2-异常检测
 *                               3-预测分析
 *                               4-决策建议
 *                               5-数据查询
 * @param {string} data.user - 用户标识符（可选）
 * @returns {Promise} 返回Promise对象
 */
export function callDifyAPI(data) {
  // 确保data是对象
  if (!data || typeof data !== 'object') {
    console.error('callDifyAPI: 参数必须是对象');
    return Promise.reject({
      status: 'error',
      message: '参数必须是对象'
    });
  }

  // 基于配置决定使用后端代理模式还是直接调用
  if (USE_BACKEND_PROXY) {
    console.log('【后端代理模式】通过Django后端代理转发请求:', data);
    
    // 构建发送到后端的数据 - 符合Dify Workflow API格式要求
    const proxyData = {
      inputs: data.inputs || {}, // 使用inputs作为主要输入
      response_mode: 'blocking', // 同步模式
      user: data.user || 'admin-user-' + Date.now(),
      api_key: DECISION_API_KEY,
      server_url: DECISION_API_SERVER
    };
    
    // 确保inputs中包含intent参数(默认为5，数据查询)，并转换为字符串
    if (!proxyData.inputs.intent) {
      const intentValue = data.intent || 5;
      proxyData.inputs.intent = String(intentValue); // 确保intent是字符串
    } else if (typeof proxyData.inputs.intent !== 'string') {
      // 如果inputs中已有intent但不是字符串，转换为字符串
      proxyData.inputs.intent = String(proxyData.inputs.intent);
    }
    
    // 添加查询内容到inputs中
    if (data.query) {
      proxyData.inputs.query = data.query;
    }
    
    console.log('【后端代理模式】准备发送数据:', JSON.stringify(proxyData));
    
    // 使用Django后端的workflow_run接口进行代理请求
    return request.post('/api/admin/dify/workflow-run', proxyData)
      .then(response => {
        console.log('【后端代理模式】响应成功:', response);
        return {
          status: 'success',
          message: '通过后端代理获取Dify响应成功',
          data: response
        }
      })
      .catch(error => {
        console.error('【后端代理模式】请求失败:', error);
        const errorDetails = {
          message: error.message,
          status: error.response?.status,
          statusText: error.response?.statusText,
          data: error.response?.data,
          url: '/api/admin/dify/workflow-run'
        };
        console.error('错误详情:', JSON.stringify(errorDetails));
        
        // 当后端代理失败时，根据设置决定是否使用模拟数据
        if (DISABLE_AUTO_FALLBACK) {
          console.warn('后端代理模式失败，已禁用自动降级，返回错误');
          return Promise.reject({
            status: 'error',
            message: '连接Dify API失败: ' + error.message,
            error: errorDetails
          });
        }
        
        console.warn('后端代理模式失败，自动切换到模拟数据模式');
        return Promise.resolve({
          status: 'success',
          message: 'Dify API响应成功(自动切换到模拟模式)',
          data: {
            answer: '由于API连接问题，系统已自动切换到模拟模式提供数据。请联系管理员检查API连接。',
            conversation_id: 'auto-mock-' + Date.now(),
            created_at: new Date().toISOString(),
            is_fallback: true
          }
        });
      });
  }
  
  // 直接调用Dify API
  // 构建请求配置 - 更新为Workflow API格式
  const config = {
    url: `${DECISION_API_SERVER}/workflows/run`,
    method: 'post',
    headers: {
      'Authorization': `Bearer ${DECISION_API_KEY}`,
      'Content-Type': 'application/json'
    },
    data: {
      inputs: data.inputs || {},
      response_mode: 'blocking', // 同步模式
      user: data.user || 'admin-user-' + Date.now()
    }
  }
  
  // 确保inputs中包含intent参数(默认为5，数据查询)，且为字符串类型
  if (!config.data.inputs.intent) {
    const intentValue = data.intent || 5;
    config.data.inputs.intent = String(intentValue); // 确保intent是字符串
    console.log(`【直接模式】设置intent为: ${config.data.inputs.intent}`);
  } else if (typeof config.data.inputs.intent !== 'string') {
    // 如果inputs中已有intent但不是字符串，转换为字符串
    config.data.inputs.intent = String(config.data.inputs.intent);
    console.log(`【直接模式】将intent转换为字符串: ${config.data.inputs.intent}`);
  }
  
  // 如果有query参数，添加到inputs中
  if (data.query) {
    config.data.inputs.query = data.query;
  }
  
  console.log('【直接模式】发送Dify Workflow API请求:', {
    url: config.url,
    method: config.method,
    inputs: config.data.inputs
  });
  
  // 直接使用 Axios 发送请求 (绕过请求拦截器)
  return request(config)
    .then(response => {
      console.log('【直接模式】Dify API响应成功:', response);
      
      // 处理Workflow API的响应格式
      const result = {
        status: 'success',
        message: 'Dify Workflow API响应成功',
        data: {}
      };
      
      // 如果是blocking模式的响应
      if (response.data) {
        result.data = {
          workflow_run_id: response.workflow_run_id,
          task_id: response.task_id,
          outputs: response.data.outputs || {},
          answer: response.data.outputs?.text || JSON.stringify(response.data.outputs)
        };
      }
      
      return result;
    })
    .catch(error => {
      console.error('【直接模式】Dify API调用失败:', error);
      // 详细记录错误信息
      const errorDetails = {
        message: error.message,
        status: error.response?.status,
        statusText: error.response?.statusText,
        data: error.response?.data
      };
      console.error('错误详情:', errorDetails);
      
      // 如果禁用自动降级，则直接返回错误
      if (DISABLE_AUTO_FALLBACK) {
        console.warn('直接模式失败，已禁用自动降级，返回错误');
        return Promise.reject({
          status: 'error',
          message: '连接Dify API失败: ' + error.message,
          error: errorDetails
        });
      }
      
      // 当直接调用失败时，自动切换到模拟数据模式
      console.warn('直接模式失败，自动切换到模拟数据模式');
      return Promise.resolve({
        status: 'success',
        message: 'Dify API响应成功(自动切换到模拟模式)',
        data: {
          answer: '由于API连接问题，系统已自动切换到模拟模式提供数据。请联系管理员检查API连接。',
          conversation_id: 'auto-mock-' + Date.now(),
          created_at: new Date().toISOString(),
          is_fallback: true
        }
      });
    });
}

/**
 * 获取异常检测数据
 * @param {Object} params - 参数对象
 * @param {string} params.timeRange - 时间范围(week/month/semester/year)
 * @param {string} params.collegeId - 学院ID，可选
 * @returns {Promise} 返回异常检测结果
 */
export function getAnomalyDetection(params) {
  console.log('获取异常检测数据:', params);
  
  if (USE_MOCK_DATA) {
    console.log('使用模拟异常检测数据');
    return mockAnomalyDetection(params);
  }
  
  // 通过Dify API获取异常检测数据
  return callDifyAPI({
    query: `检测${params.timeRange || '本学期'}的教学数据异常模式，${params.collegeId ? `针对学院ID ${params.collegeId}` : '所有学院'}`,
    intent: "2", // 设置intent为"2"，表示"异常检测"功能，使用字符串
    inputs: {  // 使用inputs而非parameters
      intent: "2", // 同时在inputs中也设置intent为字符串
      analysis_type: 'anomaly_detection',
      time_range: params.timeRange || 'semester',
      college_id: params.collegeId || 'all'
    },
    user: 'admin-anomaly-' + Date.now()
  }).then(response => {
    console.log('异常检测响应:', response);
    
    if (response.status === 'success' && response.data) {
      try {
        // 如果返回的是字符串，尝试解析为JSON
        const result = typeof response.data.answer === 'string' 
          ? JSON.parse(response.data.answer)
          : response.data;
        return {
          status: 'success',
          message: '获取异常检测数据成功',
          data: result.anomalies || result
        };
      } catch (e) {
        console.error('解析异常检测数据失败:', e);
        
        if (DISABLE_AUTO_FALLBACK) {
          return Promise.reject({
            status: 'error',
            message: '解析异常检测数据失败: ' + e.message
          });
        }
        
        console.log('切换到模拟数据');
        return mockAnomalyDetection(params);
      }
    }
    
    if (DISABLE_AUTO_FALLBACK) {
      return Promise.reject({
        status: 'error',
        message: '异常检测API返回无效数据'
      });
    }
    
    return mockAnomalyDetection(params);
  }).catch(error => {
    if (DISABLE_AUTO_FALLBACK) {
      return Promise.reject(error);
    }
    return mockAnomalyDetection(params);
  });
}

/**
 * 规范化预测数据格式
 * @param {any} data - 原始数据
 * @param {string} predictionType - 预测类型
 * @returns {Object} 规范化后的数据
 */
function normalizePredictionData(data, predictionType) {
  // 如果已经是正确格式，直接返回
  if (data && data.title && Array.isArray(data.xAxis) && Array.isArray(data.series)) {
    return data;
  }
  
  console.log('规范化预测数据格式:', {data, predictionType});
  
  // 默认数据结构
  const defaultData = {
    title: `${predictionType === 'resources' ? '教学资源需求' : 
           predictionType === 'performance' ? '学业表现' : '招生趋势'}预测`,
    xAxis: ['1月', '2月', '3月', '4月', '5月', '6月'],
    legend: predictionType === 'resources' 
      ? ['教材', '视频资源', '习题资源', '实验资源']
      : predictionType === 'performance'
      ? ['出勤率', '作业完成率', '考试通过率'] 
      : ['工学院', '理学院', '经济学院', '文学院'],
    series: []
  };
  
  // 根据预测类型生成默认系列数据
  if (predictionType === 'resources') {
    defaultData.series = [
      {
        name: '教材',
        type: 'bar',
        data: [320, 350, 290, 330, 310, 350],
        stack: 'total',
        emphasis: { focus: 'series' }
      },
      {
        name: '视频资源',
        type: 'bar',
        data: [420, 450, 500, 480, 460, 520],
        stack: 'total',
        emphasis: { focus: 'series' }
      },
      {
        name: '习题资源',
        type: 'bar',
        data: [250, 300, 270, 280, 300, 320],
        stack: 'total',
        emphasis: { focus: 'series' }
      },
      {
        name: '实验资源',
        type: 'bar',
        data: [190, 210, 230, 220, 250, 270],
        stack: 'total',
        emphasis: { focus: 'series' }
      }
    ];
  } else if (predictionType === 'performance') {
    defaultData.series = [
      {
        name: '出勤率',
        type: 'line',
        data: [85, 87, 82, 88, 86, 89]
      },
      {
        name: '作业完成率',
        type: 'line',
        data: [78, 80, 75, 82, 78, 84]
      },
      {
        name: '考试通过率',
        type: 'line',
        data: [90, 88, 91, 92, 89, 94]
      }
    ];
  } else {
    defaultData.series = [
      {
        name: '工学院',
        type: 'line',
        data: [350, 420, 380, 400, 390, 430]
      },
      {
        name: '理学院',
        type: 'line',
        data: [280, 310, 290, 300, 320, 340]
      },
      {
        name: '经济学院',
        type: 'line',
        data: [320, 350, 330, 340, 360, 370]
      },
      {
        name: '文学院',
        type: 'line',
        data: [250, 280, 270, 290, 310, 320]
      }
    ];
  }
  
  // 如果输入数据不为空，尝试合并
  if (data) {
    // 合并标题
    if (data.title) defaultData.title = data.title;
    
    // 合并X轴数据
    if (Array.isArray(data.xAxis)) defaultData.xAxis = data.xAxis;
    
    // 合并图例
    if (Array.isArray(data.legend)) defaultData.legend = data.legend;
    
    // 合并系列数据
    if (Array.isArray(data.series)) {
      defaultData.series = data.series;
    } else if (typeof data === 'object') {
      // 尝试从其他格式提取数据
      try {
        // 处理可能的嵌套结构
        const seriesData = data.series || data.data || data.prediction || data;
        
        if (Array.isArray(seriesData)) {
          defaultData.series = seriesData;
        } else if (typeof seriesData === 'object') {
          // 尝试从对象构建系列数据
          const extractedSeries = [];
          Object.keys(seriesData).forEach(key => {
            if (Array.isArray(seriesData[key])) {
              extractedSeries.push({
                name: key,
                type: predictionType === 'resources' ? 'bar' : 'line',
                data: seriesData[key],
                ...(predictionType === 'resources' ? {stack: 'total'} : {})
              });
            }
          });
          
          if (extractedSeries.length > 0) {
            defaultData.series = extractedSeries;
          }
        }
      } catch (e) {
        console.error('从响应数据提取系列数据失败:', e);
      }
    }
  }
  
  console.log('规范化后的预测数据:', defaultData);
  return defaultData;
}

/**
 * 模拟预测数据
 * @param {string} predictionType 
 * @param {Object} params 
 * @returns {Promise}
 */
function mockPrediction(predictionType, params) {
  console.log('使用模拟预测数据:', predictionType, params);
  
  // 使用规范化函数生成标准格式数据
  const result = normalizePredictionData(null, predictionType);
  
  return Promise.resolve({
    status: 'success',
    message: '生成预测数据成功',
    data: result
  });
}

/**
 * 生成教学预测
 * @param {string} predictionType - 预测类型(resources/performance/enrollment)
 * @param {Object} params - 预测参数
 * @param {string} params.timeRange - 时间范围
 * @param {string} params.collegeId - 学院ID，可选
 * @returns {Promise} 返回预测结果
 */
export function generatePrediction(predictionType, params) {
  console.log('生成教学预测:', predictionType, params);
  
  if (USE_MOCK_DATA) {
    console.log('使用模拟预测数据');
    return mockPrediction(predictionType, params);
  }
  
  // 通过Dify API获取预测分析
  return callDifyAPI({
    query: `预测${params.timeRange || '未来学期'}的${predictionType}趋势，${params.collegeId ? `针对学院ID ${params.collegeId}` : '所有学院'}`,
    intent: "3", // 设置intent为"3"，表示"预测分析"功能，使用字符串
    inputs: {
      intent: "3", // 同时在inputs中也设置intent为字符串
      analysis_type: 'prediction',
      prediction_type: predictionType,
      time_range: params.timeRange || 'future',
      college_id: params.collegeId || 'all'
    },
    user: `admin-prediction-${predictionType}-${Date.now()}`
  }).then(response => {
    console.log(`预测分析响应:`, response);
    
    if (response.status === 'success' && response.data) {
      try {
        // 如果返回的是字符串，尝试解析为JSON
        let prediction;
        if (typeof response.data.answer === 'string') {
          try {
            prediction = JSON.parse(response.data.answer);
          } catch (e) {
            console.warn('无法解析预测响应:', e);
            prediction = { error: 'JSON解析错误' };
          }
        } else {
          prediction = response.data;
        }
        
        // 规范化预测数据格式
        const normalizedData = normalizePredictionData(
          prediction, 
          predictionType
        );
        
        return {
          status: 'success',
          message: `获取预测分析成功`,
          data: normalizedData
        };
      } catch (e) {
        console.error(`解析预测分析失败:`, e);
        
        if (DISABLE_AUTO_FALLBACK) {
          return Promise.reject({
            status: 'error',
            message: `解析预测分析失败: ` + e.message
          });
        }
        
        console.log('切换到模拟数据');
        return mockPrediction(predictionType, params);
      }
    }
    
    if (DISABLE_AUTO_FALLBACK) {
      return Promise.reject({
        status: 'error',
        message: `获取预测分析API返回无效数据`
      });
    }
    
    return mockPrediction(predictionType, params);
  }).catch(error => {
    if (DISABLE_AUTO_FALLBACK) {
      return Promise.reject(error);
    }
    return mockPrediction(predictionType, params);
  });
}

/**
 * 获取AI决策建议
 * @param {string} category - 建议类别(teaching/resources/student/enrollment)
 * @param {Object} params - 参数对象
 * @param {string} params.timeRange - 时间范围(week/month/semester/year)
 * @param {string} params.collegeId - 学院ID，可选
 * @returns {Promise} 决策建议结果
 */
export function getDecisionRecommendations(category, params) {
  console.log('获取决策建议:', category, params);
  
  if (USE_MOCK_DATA) {
    console.log('使用模拟决策建议数据');
    return mockRecommendations(category, params);
  }
  
  // 查询建议
  const query = `针对${category}方面，请提供${params.timeRange || '本学期'}的${params.collegeId ? `学院ID ${params.collegeId}` : '所有学院'}决策建议`;
  
  // 通过Dify API获取决策建议
  return callDifyAPI({
    query: query,
    intent: "4", // 设置intent为"4"，表示"决策建议"功能，使用字符串
    inputs: {
      intent: "4", // 同时在inputs中也设置intent为字符串
      category: category,
      time_range: params.timeRange || 'semester',
      college_id: params.collegeId || 'all'
    },
    user: `admin-recommendation-${category}-${Date.now()}`
  }).then(response => {
    console.log(`决策建议响应:`, response);
    
    if (response.status === 'success' && response.data) {
      try {
        // 尝试解析响应
        const result = typeof response.data.answer === 'string'
          ? JSON.parse(response.data.answer)
          : response.data;
          
        // 格式化建议，确保数据结构一致
        const formattedRecommendations = formatRecommendations(result.recommendations || result);
        console.log('格式化后的建议:', formattedRecommendations);
        
        // 如果没有获取到有效的建议数据，使用模拟数据
        if (!formattedRecommendations || formattedRecommendations.length === 0) {
          console.warn('API返回的建议为空，切换到模拟数据');
          if (DISABLE_AUTO_FALLBACK) {
            return Promise.reject({
              status: 'error',
              message: '获取到的建议数据为空'
            });
          }
          return mockRecommendations(category, params);
        }
        
        return {
          status: 'success',
          message: `获取决策建议成功`,
          data: formattedRecommendations
        };
      } catch (e) {
        console.error(`解析决策建议失败:`, e);
        
        if (DISABLE_AUTO_FALLBACK) {
          return Promise.reject({
            status: 'error',
            message: `解析决策建议失败: ` + e.message
          });
        }
        
        console.log('切换到模拟数据');
        return mockRecommendations(category, params);
      }
    }
    
    if (DISABLE_AUTO_FALLBACK) {
      return Promise.reject({
        status: 'error',
        message: `获取决策建议API返回无效数据`
      });
    }
    
    return mockRecommendations(category, params);
  }).catch(error => {
    if (DISABLE_AUTO_FALLBACK) {
      return Promise.reject(error);
    }
    return mockRecommendations(category, params);
  });
}

/**
 * 提交用户对建议的反馈
 * @param {Object} data - 反馈数据
 * @param {string} data.recommendationId - 建议ID
 * @param {string} data.action - 操作(adopt/ignore)
 * @param {string} data.category - 建议类别
 * @param {string} data.feedback - 额外反馈，可选
 * @returns {Promise} 返回反馈处理结果
 */
export function submitRecommendationFeedback(data) {
  if (USE_MOCK_DATA) {
    return mockFeedback(data)
  }
  
  // 通过Dify API提交反馈（用于模型训练）
  return callDifyAPI({
    query: `用户${data.action === 'adopt' ? '采纳' : '忽略'}了建议：${data.recommendationId}，类别：${data.category}`,
    inputs: {
      feedback_type: 'recommendation_feedback',
      action: data.action,
      recommendation_id: data.recommendationId,
      category: data.category,
      user_feedback: data.feedback || null
    }
  }).then(response => {
    if (response.status === 'success') {
      return {
        status: 'success',
        message: `反馈提交成功，已${data.action === 'adopt' ? '采纳' : '忽略'}建议`,
        data: {
          id: data.recommendationId,
          action: data.action,
          category: data.category,
          processed_at: new Date().toISOString()
        }
      };
    }
    return mockFeedback(data);
  })
}

/**
 * 使用AI分析教学数据
 * @param {Object} params - 分析参数
 * @param {string} params.analysisType - 分析类型
 * @param {Object} params.data - 分析数据
 * @returns {Promise} 返回分析结果
 */
export function analyzeTeachingData(params) {
  if (USE_MOCK_DATA) {
    return mockAnalyzeData(params)
  }
  
  // 通过Dify API分析教学数据
  return callDifyAPI({
    query: `分析${params.analysisType}类型的教学数据`,
    inputs: {
      analysis_type: params.analysisType,
      data: params.data || {}
    }
  }).then(response => {
    if (response.status === 'success' && response.data) {
      try {
        // 尝试解析响应
        const result = typeof response.data.answer === 'string' 
          ? JSON.parse(response.data.answer)
          : response.data;
        return {
          status: 'success',
          message: '分析教学数据成功',
          data: result.analysis || result
        };
      } catch (e) {
        console.error('解析教学数据分析结果失败:', e);
        return mockAnalyzeData(params);
      }
    }
    return mockAnalyzeData(params);
  })
}

/**
 * 智能检测查询类型，与Dify工作流中的意图分类对应
 * @param {string} query - 查询内容
 * @returns {string} 查询类型
 */
function detectQueryType(query) {
  const lowerQuery = query.toLowerCase();
  
  // CASE 1 - 包含类别的意图：课程设置、资源配置、教学方法、评估方案
  if (lowerQuery.includes('课程设置') || lowerQuery.includes('课程建议') || lowerQuery.includes('教学计划')) {
    return 'curriculum';
  }
  
  if (lowerQuery.includes('资源配置') || lowerQuery.includes('教学资源') || lowerQuery.includes('教材')) {
    return 'resource';
  }
  
  if (lowerQuery.includes('教学方法') || lowerQuery.includes('授课方式') || lowerQuery.includes('教学技巧')) {
    return 'teaching';
  }
  
  if (lowerQuery.includes('评估方案') || lowerQuery.includes('考核方式') || lowerQuery.includes('学习评价')) {
    return 'evaluation';
  }
  
  // CASE 2 - 异常检测相关意图
  if (lowerQuery.includes('异常') || lowerQuery.includes('偏差') || lowerQuery.includes('问题发现') || 
      lowerQuery.includes('预警') || lowerQuery.includes('风险')) {
    return 'anomaly_detection';
  }
  
  // CASE 3 - 趋势分析相关意图
  if (lowerQuery.includes('趋势') || lowerQuery.includes('变化') || lowerQuery.includes('走势') || 
      lowerQuery.includes('预测') || lowerQuery.includes('未来') || lowerQuery.includes('发展')) {
    return 'trend_analysis';
  }
  
  // CASE 4 - 查询分析相关意图
  if (lowerQuery.includes('比较') || lowerQuery.includes('对比') || lowerQuery.includes('分析')) {
    return 'comparison_analysis'; 
  }
  
  if (lowerQuery.includes('分布') || lowerQuery.includes('占比') || lowerQuery.includes('统计')) {
    return 'distribution_analysis';
  }
  
  if (lowerQuery.includes('原因') || lowerQuery.includes('为什么')) {
    return 'reason_analysis';
  }
  
  // CASE 5 - 教学评估相关意图
  if (lowerQuery.includes('教学质量') || lowerQuery.includes('教学评估') || 
      lowerQuery.includes('师资') || lowerQuery.includes('教师水平')) {
    return 'teaching_quality';
  }
  
  // 默认情况
  if (lowerQuery.includes('建议') || lowerQuery.includes('如何改进') || lowerQuery.includes('怎么办')) {
    return 'recommendation';
  }
  
  return 'general';
}

/**
 * 执行自然语言查询
 * @param {Object} params - 查询参数
 * @param {string} params.query - 自然语言查询内容
 * @param {string} params.timeRange - 时间范围(week/month/semester/year)
 * @param {string} params.collegeId - 学院ID，可选
 * @returns {Promise} 返回查询结果
 */
export function nlQuery(params) {
  console.log('执行自然语言查询:', params);
  
  if (USE_MOCK_DATA) {
    console.log('使用模拟自然语言查询数据');
    return mockNLQuery(params);
  }
  
  // 如果没有查询文本，则返回错误
  if (!params.query || typeof params.query !== 'string') {
    return Promise.reject({
      status: 'error',
      message: '查询内容不能为空'
    });
  }
  
  // 提前检测查询类型
  const queryType = detectQueryType(params.query);
  console.log('检测到查询类型:', queryType);
  
  // 构建请求数据
  // 通过Dify API执行自然语言查询
  return callDifyAPI({
    query: params.query,
    intent: "5", // 设置intent为"5"，表示"数据查询"功能，使用字符串
    inputs: {
      intent: "5", // 在inputs中也设置intent为字符串
      query_type: queryType,
      time_range: params.timeRange || 'semester',
      college_id: params.collegeId || 'all'
    },
    user: 'admin-nlquery-' + Date.now()
  })
  .then(response => {
    console.log('自然语言查询响应:', response);
    
    if (response.status === 'success' && response.data) {
      try {
        // 尝试解析响应
        let result;
        const answerText = response.data.answer || '';
        
        // 首先检查是否为JSON格式 - 适用于结构化结果
        try {
          // 尝试直接解析整个答案
          result = JSON.parse(answerText);
          console.log('成功解析查询响应为JSON');
        } catch(e) {
          console.log('响应不是JSON格式，作为文本处理');
          // 如果不是JSON，则作为文本处理
          result = {
            type: 'text',
            content: answerText
          };
        }
        
        // 根据查询类型和结果添加额外信息
        const enhancedResult = {
          ...result,
          query: params.query,
          query_type: queryType,
          time_range: params.timeRange || 'semester'
        };
        
        return {
          status: 'success',
          message: '自然语言查询成功',
          data: enhancedResult
        };
      } catch (e) {
        console.error('处理自然语言查询响应失败:', e);
        
        if (DISABLE_AUTO_FALLBACK) {
          return Promise.reject({
            status: 'error',
            message: '处理自然语言查询响应失败: ' + e.message
          });
        }
        
        console.log('切换到模拟数据');
        return mockNLQuery(params);
      }
    }
    
    if (DISABLE_AUTO_FALLBACK) {
      return Promise.reject({
        status: 'error',
        message: '自然语言查询API返回无效数据'
      });
    }
    
    return mockNLQuery(params);
  }).catch(error => {
    if (DISABLE_AUTO_FALLBACK) {
      return Promise.reject(error);
    }
    return mockNLQuery(params);
  });
}

/**
 * 格式化推荐结果为文本
 * @param {Array|Object} recommendations - 推荐列表，可能是数组、对象或其他格式
 * @returns {Array} 格式化后的推荐数组
 */
function formatRecommendations(recommendations) {
  console.log('格式化推荐数据，原始数据:', recommendations);
  
  // 如果recommendations为空或不存在
  if (!recommendations) {
    console.warn('推荐数据为空或不存在');
    return [];
  }
  
  // 如果recommendations已经是数组，检查并处理
  if (Array.isArray(recommendations)) {
    console.log('推荐数据已经是数组，长度:', recommendations.length);
    if (recommendations.length === 0) {
      return [];
    }
    return recommendations;
  }
  
  // 如果recommendations是对象，尝试提取数组
  if (typeof recommendations === 'object') {
    console.log('推荐数据是对象，尝试提取数组');
    // 尝试各种可能的字段名
    if (recommendations.recommendations && Array.isArray(recommendations.recommendations)) {
      return recommendations.recommendations;
    }
    if (recommendations.items && Array.isArray(recommendations.items)) {
      return recommendations.items;
    }
    if (recommendations.results && Array.isArray(recommendations.results)) {
      return recommendations.results;
    }
    if (recommendations.data && Array.isArray(recommendations.data)) {
      return recommendations.data;
    }
    
    // 如果以上都不存在，尝试将对象转换为数组
    try {
      // 检查对象是否可以作为数组项
      if (recommendations.title || recommendations.content) {
        return [recommendations];
      }
      
      // 如果对象不是明显的推荐项，尝试创建一个基于该对象的推荐
      const defaultRec = {
        id: 'generated',
        title: '系统推荐',
        content: typeof recommendations === 'string' ? recommendations : JSON.stringify(recommendations),
        confidence: 80
      };
      return [defaultRec];
    } catch (e) {
      console.error('转换推荐数据失败:', e);
      return [];
    }
  }
  
  // 如果是字符串，尝试解析
  if (typeof recommendations === 'string') {
    console.log('推荐数据是字符串，尝试解析');
    try {
      const parsed = JSON.parse(recommendations);
      return formatRecommendations(parsed); // 递归调用处理解析后的数据
    } catch (e) {
      console.warn('无法解析推荐数据字符串:', e);
      // 将字符串作为单个推荐内容
      return [{
        id: 'text',
        title: '系统推荐',
        content: recommendations,
        confidence: 75
      }];
    }
  }
  
  // 兜底返回空数组
  console.warn('无法处理的推荐数据格式:', typeof recommendations);
  return [];
}

/**
 * 格式化异常检测结果为文本
 * @param {Array} anomalies - 异常列表
 * @returns {string} 格式化后的文本
 */
function formatAnomalies(anomalies) {
  if (!anomalies || anomalies.length === 0) {
    return '未检测到异常。';
  }
  
  return anomalies.map((anomaly, index) => {
    const levelText = anomaly.level === 'high' ? '❗高风险' : 
                      (anomaly.level === 'medium' ? '⚠️中风险' : 'ℹ️低风险');
    return `${index + 1}. [${levelText}] ${anomaly.title}:\n   ${anomaly.description}`;
  }).join('\n\n');
}

/**
 * 格式化预测结果为文本
 * @param {Object} data - 预测数据
 * @param {string} type - 预测类型
 * @returns {string} 格式化后的文本
 */
function formatPrediction(data, type) {
  if (!data) {
    return '无法生成预测数据。';
  }
  
  if (data.title) {
    let result = `${data.title}\n\n`;
    
    if (data.summary) {
      result += `总体趋势: ${data.summary}\n\n`;
    }
    
    if (data.predictions && data.predictions.length > 0) {
      result += '详细预测:\n';
      data.predictions.forEach((pred, index) => {
        result += `${index + 1}. ${pred.period}: ${pred.value} ${pred.unit || ''}\n`;
      });
    }
    
    return result;
  }
  
  return JSON.stringify(data, null, 2);
}

/**
 * 格式化教学质量评估结果为文本
 * @param {Object} data - 质量评估数据
 * @returns {string} 格式化后的文本
 */
function formatTeachingQuality(data) {
  if (!data || !data.colleges) {
    return '无法获取教学质量评估数据。';
  }
  
  let result = '教学质量评估报告\n\n';
  
  data.colleges.forEach(college => {
    result += `${college.name}:\n`;
    
    if (college.metrics) {
      Object.entries(college.metrics).forEach(([key, value]) => {
        const metricName = data.metrics_description?.[key] || key;
        result += `  - ${metricName}: ${value}\n`;
      });
    }
    
    result += '\n';
  });
  
  return result;
}

/**
 * 获取学院教学质量指标
 * @param {Object} params - 查询参数
 * @param {string} params.collegeId - 学院ID，可选
 * @param {string} params.timeRange - 时间范围
 * @returns {Promise} 返回学院教学质量指标
 */
export function getTeachingQualityMetrics(params) {
  if (USE_MOCK_DATA) {
    return mockTeachingQuality(params)
  }
  
  // 通过Dify API获取教学质量指标
  return callDifyAPI({
    query: `获取${params.timeRange || '当前学期'}的教学质量指标，${params.collegeId ? `针对学院ID ${params.collegeId}` : '所有学院'}`,
    inputs: {
      analysis_type: 'teaching_quality',
      time_range: params.timeRange,
      college_id: params.collegeId || 'all'
    }
  }).then(response => {
    if (response.status === 'success' && response.data) {
      try {
        // 尝试解析响应
        const result = typeof response.data.answer === 'string' 
          ? JSON.parse(response.data.answer)
          : response.data;
        return {
          status: 'success',
          message: '获取教学质量指标成功',
          data: result.metrics || result
        };
      } catch (e) {
        console.error('解析教学质量指标失败:', e);
        return mockTeachingQuality(params);
      }
    }
    return mockTeachingQuality(params);
  })
}

/**
 * 生成教育资源优化方案
 * @param {Object} params - 优化参数
 * @param {string} params.resourceType - 资源类型
 * @param {string} params.collegeId - 学院ID，可选
 * @param {string} params.optimizationTarget - 优化目标
 * @returns {Promise} 返回资源优化方案
 */
export function generateResourceOptimization(params) {
  if (USE_MOCK_DATA) {
    return mockResourceOptimization(params)
  }
  
  // 通过Dify API生成资源优化方案
  return callDifyAPI({
    query: `为${params.resourceType}类型的教育资源生成优化方案，
            优化目标为${params.optimizationTarget || '提高使用效率'}，
            ${params.collegeId ? `针对学院ID ${params.collegeId}` : '所有学院'}`,
    inputs: {
      resource_type: params.resourceType,
      optimization_target: params.optimizationTarget,
      college_id: params.collegeId || 'all'
    }
  }).then(response => {
    if (response.status === 'success' && response.data) {
      try {
        // 尝试解析响应
        const result = typeof response.data.answer === 'string' 
          ? JSON.parse(response.data.answer)
          : response.data;
        return {
          status: 'success',
          message: '生成资源优化方案成功',
          data: result.optimization_plan || result
        };
      } catch (e) {
        console.error('解析资源优化方案失败:', e);
        return mockResourceOptimization(params);
      }
    }
    return mockResourceOptimization(params);
  })
}

/**
 * 测试决策系统连接 - 更新为Workflow API格式
 * @returns {Promise} 返回连接测试结果
 */
export function testDecisionSystemConnection() {
  console.log('测试AI决策系统连接');
  
  // 基于配置决定测试流程
  if (USE_BACKEND_PROXY) {
    console.log('【后端代理模式】测试后端代理连接');
    // 通过Django后端代理测试
    return request.post('/api/admin/ai/test-decision-connection/', {
      api_key: DECISION_API_KEY,
      server_url: DECISION_API_SERVER,
      is_workflow: true,
      test_intent: true  // 添加测试intent标志
    }).then(response => {
      console.log('后端代理测试响应:', response);
      return {
        status: 'success',
        message: '连接测试成功：后端代理可以连接到Dify服务'
      };
    }).catch(error => {
      console.error('后端代理测试失败:', error);
      return Promise.reject({
        status: 'error',
        message: '连接测试失败: ' + (error.message || '未知错误')
      });
    });
  } else {
    console.log('【直接模式】测试工作流API连接');
    // 直接测试工作流API
    return testDirectWorkflowConnection();
  }
}

/**
 * 直接测试Dify Workflow API连接
 * @private
 * @returns {Promise} 测试结果
 */
function testDirectWorkflowConnection() {
  // 构建请求配置 - 简单测试请求
  const config = {
    url: `${DECISION_API_SERVER}/workflows/run`,
    method: 'post',
    headers: {
      'Authorization': `Bearer ${DECISION_API_KEY}`,
      'Content-Type': 'application/json'
    },
    data: {
      inputs: {
        intent: "5",  // 使用字符串类型intent值，数据查询类型
        query: "测试连接",
        test: true
      },
      response_mode: 'blocking',
      user: 'admin-test-connection-' + Date.now()
    }
  }
  
  console.log('发送测试连接请求:', config.url);
  
  // 直接使用axios发送请求
  return axios(config)
    .then(response => {
      console.log('工作流API测试响应:', response.status, response.data);
      return {
        status: 'success',
        message: '连接测试成功：可以直接连接到Dify工作流API',
        data: response.data
      };
    })
    .catch(error => {
      console.error('工作流API测试失败:', error);
      
      // 构建详细错误信息
      const errorDetails = {
        message: error.message,
        status: error.response?.status,
        statusText: error.response?.statusText,
        data: error.response?.data
      };
      
      return Promise.reject({
        status: 'error',
        message: '连接测试失败: ' + error.message,
        error: errorDetails
      });
    });
}

// ===== 模拟数据函数 =====

/**
 * 模拟异常检测数据
 * @param {Object} params 
 * @returns {Promise}
 */
function mockAnomalyDetection(params) {
  console.log('使用模拟异常检测数据:', params)
  
  // 异常模式模拟数据
  const anomalies = [
    {
      level: 'high',
      title: '学生出勤率异常下降',
      description: '工学院自动化专业2023级近两周出勤率下降15%，可能影响期末考试成绩。',
      data: {
        current: 75,
        previous: 90,
        change: -15
      }
    },
    {
      level: 'medium',
      title: '资源使用异常',
      description: '经济学院金融学专业教学资源下载量较上月下降30%，建议排查资源质量。',
      data: {
        current: 320,
        previous: 457,
        change: -30
      }
    },
    {
      level: 'low',
      title: '成绩分布异常',
      description: '计算机科学学院软件工程《数据库系统》课程成绩分布呈双峰状态，或存在教学不均衡现象。',
      data: {
        distribution: [5, 8, 12, 15, 20, 18, 10, 22, 25, 15],
        expected: 'normal'
      }
    }
  ]
  
  // 根据时间范围添加不同的异常
  if (params.timeRange === 'week') {
    anomalies.push({
      level: 'high',
      title: '在线作业完成率急剧下降',
      description: '过去一周，工学院大多数专业的在线作业完成率下降超过20%，疑似系统故障或期末压力导致。',
      data: {
        current: 65,
        previous: 85,
        change: -20
      }
    })
  } else if (params.timeRange === 'month') {
    anomalies.push({
      level: 'medium',
      title: '教师线上答疑活跃度降低',
      description: '过去一个月，全校教师的线上答疑平台活跃度平均下降25%，建议排查原因或提供使用激励。',
      data: {
        current: 45,
        previous: 60,
        change: -25
      }
    })
  }
  
  return Promise.resolve({
    status: 'success',
    message: '获取异常检测数据成功',
    data: anomalies
  })
}

/**
 * 模拟推荐数据
 * @param {string} category 
 * @param {Object} params 
 * @returns {Promise}
 */
function mockRecommendations(category, params) {
  console.log('使用模拟推荐数据:', category, params)
  
  let recommendations = []
  
  if (category === 'curriculum') {
    recommendations = [
      {
        id: 'curr_1',
        category: 'curriculum',
        title: '增加实践课程比例',
        content: '根据学生学习行为分析，建议在计算机科学专业增加实践课程比例，从当前的30%提高到40%，以提升学生动手能力和项目经验。',
        confidence: 85
      },
      {
        id: 'curr_2',
        category: 'curriculum',
        title: '调整高数课程进度',
        content: '数据显示大一学生在高等数学第一学期的失败率较高，建议将课程内容分散到更长时间段，并增加阶段性辅导。',
        confidence: 78
      },
      {
        id: 'curr_3',
        category: 'curriculum',
        title: '引入跨学科课程',
        content: '当前就业市场对复合型人才需求增加，建议在专业课程中增加跨学科内容，如计算机专业增加商业和设计思维课程。',
        confidence: 83
      }
    ]
  } else if (category === 'resource') {
    recommendations = [
      {
        id: 'res_1',
        category: 'resource',
        title: '扩充机器学习资源库',
        content: '人工智能相关课程的资源访问量增长了75%，建议扩充机器学习、深度学习等相关教学资源，尤其是实践项目案例。',
        confidence: 92
      },
      {
        id: 'res_2',
        category: 'resource',
        title: '优化移动端资源访问',
        content: '超过65%的学生通过移动设备访问教学资源，建议优化资源平台的移动端适配性，提升用户体验。',
        confidence: 87
      },
      {
        id: 'res_3',
        category: 'resource',
        title: '增加交互式学习内容',
        content: '分析显示，具有交互性的学习资源完成率高出传统资源25%，建议增加模拟实验、互动问答等教学内容。',
        confidence: 81
      }
    ]
  } else if (category === 'teaching') {
    recommendations = [
      {
        id: 'teach_1',
        category: 'teaching',
        title: '采用混合式教学模式',
        content: '分析表明，混合在线和线下教学的课程学生参与度提高了23%，建议更多课程采用混合式教学模式。',
        confidence: 89
      },
      {
        id: 'teach_2',
        category: 'teaching',
        title: '增加小组协作项目',
        content: '有小组协作项目的课程学生满意度平均高出17个百分点，建议在专业核心课程中增加团队协作环节。',
        confidence: 82
      },
      {
        id: 'teach_3',
        category: 'teaching',
        title: '引入实时反馈系统',
        content: '使用课堂实时反馈系统的教师教学评价提高了15%，建议在更多课程中采用数字化反馈工具。',
        confidence: 78
      }
    ]
  } else {
    recommendations = [
      {
        id: 'eval_1',
        category: 'evaluation',
        title: '多维度评估体系',
        content: '单一考试评估方式导致学生学习行为短期化，建议实施包含过程考核、项目评估、同伴评价等多维度评估体系。',
        confidence: 91
      },
      {
        id: 'eval_2',
        category: 'evaluation',
        title: '引入形成性评估',
        content: '实施形成性评估的课程中，学生学习投入时间增加了31%，建议在更多课程中引入阶段性形成性评估。',
        confidence: 84
      },
      {
        id: 'eval_3',
        category: 'evaluation',
        title: '基于能力的评估模型',
        content: '基于能力评估的课程与行业需求对接更紧密，毕业生就业率高出传统评估课程12%，建议推广能力导向评估。',
        confidence: 88
      }
    ]
  }
  
  return Promise.resolve({
    status: 'success',
    message: '获取决策建议成功',
    data: recommendations
  })
}

/**
 * 模拟反馈提交
 * @param {Object} data 
 * @returns {Promise}
 */
function mockFeedback(data) {
  console.log('提交模拟反馈:', data)
  return Promise.resolve({
    status: 'success',
    message: `反馈提交成功，已${data.action === 'adopt' ? '采纳' : '忽略'}建议`,
    data: {
      id: data.recommendationId,
      action: data.action,
      category: data.category,
      processed_at: new Date().toISOString()
    }
  })
}

/**
 * 模拟数据分析
 * @param {Object} params 
 * @returns {Promise}
 */
function mockAnalyzeData(params) {
  console.log('使用模拟分析数据:', params)
  
  let result = {}
  
  if (params.analysisType === 'student_performance') {
    result = {
      summary: '学生整体表现良好，平均成绩82.5分，优秀率35%，不及格率5%',
      trends: {
        average_scores: [78.2, 80.1, 82.5],
        excellence_rate: [30, 32, 35],
        fail_rate: [8, 6, 5]
      },
      recommendations: [
        '关注不及格学生，提供针对性辅导',
        '鼓励优秀学生参与学科竞赛和研究项目',
        '优化教学内容，增加实践环节'
      ]
    }
  } else if (params.analysisType === 'teaching_quality') {
    result = {
      summary: '教学质量评价总体良好，平均评分4.6/5，满意度88%',
      strengths: ['教师专业素养', '课程内容设计', '学生互动'],
      weaknesses: ['答疑效率', '作业反馈时间', '教学资源多样性'],
      recommendations: [
        '优化线上答疑系统，提高响应速度',
        '增加教学助理，缩短作业反馈周期',
        '丰富教学资源形式，增加多媒体和互动内容'
      ]
    }
  } else {
    result = {
      summary: '教学资源使用率75%，视频资源最受欢迎，电子书使用率偏低',
      resource_usage: {
        video: 85,
        practice: 78,
        document: 65,
        ebook: 52
      },
      peak_times: ['星期一上午', '星期三下午', '星期日晚上'],
      recommendations: [
        '优化电子书阅读体验，增加互动功能',
        '根据使用高峰期增加服务器资源',
        '根据学生反馈调整视频内容长度和节奏'
      ]
    }
  }
  
  return Promise.resolve({
    status: 'success',
    message: '分析教学数据成功',
    data: result
  })
}

/**
 * 模拟自然语言查询
 * @param {Object} params 
 * @returns {Promise}
 */
function mockNLQuery(params) {
  console.log('模拟自然语言查询:', params)
  
  const query = params.query.toLowerCase()
  let result = ''
  
  if (query.includes('成绩') || query.includes('分数')) {
    result = `${params.timeRange}内，全校平均成绩为82.5分，比上期提高1.2分。计算机科学学院平均分最高，达到86.3分，文学院进步最大，提升3.1分。`
  } else if (query.includes('出勤') || query.includes('考勤')) {
    result = `${params.timeRange}内，全校平均出勤率为92.7%，工学院出勤率最高，达到95.3%，经济学院出勤率最低，为88.2%。`
  } else if (query.includes('资源') || query.includes('教材')) {
    result = `${params.timeRange}内，学习资源平台访问量增长15%，电子教材下载量增长23%，视频资源观看时长增长31%。`
  } else if (query.includes('平均')) {
    result = `${params.timeRange}内，文学院的平均成绩提升最多，从78.3分提高到81.4分，提升了3.1分。其次是经济学院，提升了2.5分。`
  } else {
    result = `在${params.timeRange}内，教学整体运行良好，学生平均成绩82.5分，教师满意度88%，资源使用率75%。详细数据请查看各模块报告。`
  }
  
  return Promise.resolve({
    status: 'success',
    message: '查询处理成功',
    data: {
      result,
      query: params.query,
      conversation_id: 'mock-conv-' + Date.now(),
      is_mock: true
    }
  })
}

/**
 * 模拟教学质量指标
 * @param {Object} params 
 * @returns {Promise}
 */
function mockTeachingQuality(params) {
  console.log('使用模拟教学质量指标:', params)
  
  const colleges = [
    {
      id: 1,
      name: '计算机科学学院',
      metrics: {
        teaching_satisfaction: 92,
        student_pass_rate: 95,
        resource_satisfaction: 88,
        teacher_evaluation: 4.7,
        curriculum_rationality: 4.5,
        practice_opportunity: 4.8
      }
    },
    {
      id: 2,
      name: '工学院',
      metrics: {
        teaching_satisfaction: 90,
        student_pass_rate: 93,
        resource_satisfaction: 85,
        teacher_evaluation: 4.6,
        curriculum_rationality: 4.3,
        practice_opportunity: 4.9
      }
    },
    {
      id: 3,
      name: '经济学院',
      metrics: {
        teaching_satisfaction: 88,
        student_pass_rate: 91,
        resource_satisfaction: 82,
        teacher_evaluation: 4.5,
        curriculum_rationality: 4.4,
        practice_opportunity: 4.2
      }
    }
  ]
  
  return Promise.resolve({
    status: 'success',
    message: '获取教学质量指标成功',
    data: {
      colleges,
      metrics_description: {
        teaching_satisfaction: '教学满意度(%)',
        student_pass_rate: '学生通过率(%)',
        resource_satisfaction: '资源满意度(%)',
        teacher_evaluation: '教师评价(1-5分)',
        curriculum_rationality: '课程合理性(1-5分)',
        practice_opportunity: '实践机会(1-5分)'
      }
    }
  })
}

/**
 * 模拟资源优化方案
 * @param {Object} params 
 * @returns {Promise}
 */
function mockResourceOptimization(params) {
  console.log('使用模拟资源优化方案:', params)
  
  let result = {}
  
  if (params.resourceType === 'classroom') {
    result = {
      summary: '教室使用效率可提升18%，通过优化排课算法和调整使用时段',
      current_status: {
        usage_rate: 72,
        peak_time_congestion: 85,
        off_peak_vacancy: 35
      },
      optimization_plan: {
        steps: [
          '实施智能排课系统，基于历史数据和课程特性自动分配教室',
          '调整部分非核心课程到非高峰时段',
          '根据课程人数和教室容量进行精确匹配，避免大教室小班级现象',
          '开放教室实时预约系统，提高临时使用效率'
        ],
        expected_improvement: {
          usage_rate: 85,
          vacancy_reduction: 40,
          congestion_reduction: 30
        },
        implementation_cost: 'medium',
        timeframe: '1-2个学期'
      }
    }
  } else if (params.resourceType === 'digital') {
    result = {
      summary: '数字教学资源利用率可提升25%，通过内容优化和界面改进',
      current_status: {
        usage_rate: 65,
        user_satisfaction: 75,
        resource_coverage: 80
      },
      optimization_plan: {
        steps: [
          '基于学生行为数据重新组织资源结构，突出高频使用内容',
          '优化移动端界面，提升用户体验',
          '增加互动式内容，提高学习参与度',
          '实施个性化推荐系统，为学生推送最相关资源'
        ],
        expected_improvement: {
          usage_rate: 85,
          user_satisfaction: 90,
          learning_efficiency: 20
        },
        implementation_cost: 'medium to high',
        timeframe: '3-6个月'
      }
    }
  } else {
    result = {
      summary: '教师资源分配可优化15%，通过专业匹配和负载均衡',
      current_status: {
        workload_balance: 65,
        specialty_match: 75,
        teacher_satisfaction: 70
      },
      optimization_plan: {
        steps: [
          '基于专业背景和教学评价重新分配课程',
          '平衡教师工作负载，避免部分教师过度负担',
          '引入"教学团队"模式，促进教师间协作和资源共享',
          '建立教师培训和发展计划，提升整体教学能力'
        ],
        expected_improvement: {
          workload_balance: 85,
          specialty_match: 90,
          teacher_satisfaction: 85
        },
        implementation_cost: 'low',
        timeframe: '1个学期'
      }
    }
  }
  
  return Promise.resolve({
    status: 'success',
    message: '生成资源优化方案成功',
    data: result
  })
}

/**
 * 获取教学数据概览卡片信息
 * @param {Object} params - 请求参数
 * @param {String} params.timeRange - 时间范围：week/month/semester/year
 * @returns {Promise} 返回概览数据
 */
export function getOverviewData(params) {
  console.log('获取数据概览:', params);
  
  if (USE_MOCK_DATA) {
    console.log('使用模拟数据概览数据');
    return mockOverviewData(params);
  }
  
  // 使用Dify API获取数据概览
  const timeRange = params.timeRange || 'semester';
  
  let query = `获取${timeRange}的教育数据概览`;
  if (params.collegeId) {
    query += `，针对学院ID ${params.collegeId}`;
  }
  if (params.view) {
    query += `，视图类型 ${params.view}`;
  }
  
  // 调用Dify API获取概览数据
  return callDifyAPI({
    query: query,
    intent: "1",  // 设置intent为"1"，表示"数据概览"功能，使用字符串
    inputs: {
      intent: "1", // 同时在inputs中也设置intent为字符串
      analysis_type: 'overview',
      time_range: timeRange,
      college_id: params.collegeId || 'all',
      view_type: params.view || 'overview'
    },
    user: 'admin-overview-' + Date.now()
  }).then(response => {
    console.log('数据概览响应:', response);
    
    if (response.status === 'success' && response.data) {
      try {
        // 如果返回的是字符串，尝试解析
        const result = typeof response.data.answer === 'string' 
          ? JSON.parse(response.data.answer)
          : response.data;
          
        // 返回规范化的数据
        if (Array.isArray(result)) {
          // 已经是数组格式
          return {
            status: 'success',
            message: '获取数据概览成功',
            data: result
          };
        } else if (typeof result === 'object') {
          // 对象格式，需要提取metrics或data字段
          const metrics = result.metrics || result.data || [];
          return {
            status: 'success',
            message: '获取数据概览成功',
            data: metrics
          };
        } else if (typeof result.answer === 'string') {
          // 将文本转换为指标数据
          const metrics = parseOverviewDataFromText(result.answer, timeRange);
          return {
            status: 'success',
            message: '获取数据概览成功(文本转换)',
            data: metrics
          };
        }
      } catch (e) {
        console.error('解析数据概览结果失败:', e);
        
        if (DISABLE_AUTO_FALLBACK) {
          return Promise.reject({
            status: 'error',
            message: '解析数据概览结果失败: ' + e.message,
          });
        }
        
        console.log('切换到模拟数据');
        return mockOverviewData(params);
      }
    }
    
    if (DISABLE_AUTO_FALLBACK) {
      return Promise.reject({
        status: 'error',
        message: '获取数据概览API返回无效数据'
      });
    }
    
    return mockOverviewData(params);
  }).catch(error => {
    if (DISABLE_AUTO_FALLBACK) {
      return Promise.reject(error);
    }
    
    return mockOverviewData(params);
  });
}

/**
 * 从文本中解析概览数据 - 增强版
 * @param {String} text - Dify返回的文本
 * @param {String} timeRange - 时间范围
 * @returns {Array} 解析后的概览卡片数据
 */
function parseOverviewDataFromText(text, timeRange) {
  // 预设的指标名称和颜色
  const indicators = [
    { 
      keywords: ['资源', '利用'], 
      title: '教学资源利用率',
      icon: '📚',
      color: '#1890ff'
    },
    { 
      keywords: ['质量', '评分'], 
      title: '平均教学质量评分',
      icon: '⭐',
      color: '#52c41a'
    },
    { 
      keywords: ['参与', '出勤'], 
      title: '学生参与度',
      icon: '👥',
      color: '#722ed1'
    },
    { 
      keywords: ['缺口', '不足'], 
      title: '教学资源缺口',
      icon: '📊',
      color: '#faad14'
    }
  ];
  
  // 解析结果数组
  const results = [];
  
  // 按行分割文本
  const lines = text.split('\n');
  
  // 遍历每一行寻找指标数据
  for (const line of lines) {
    const trimmedLine = line.trim();
    if (!trimmedLine) continue;
    
    // 尝试提取数值和变化率
    const valueMatch = trimmedLine.match(/([0-9.]+%?|[0-9.]+\/[0-9.]+)/);
    const changeMatch = trimmedLine.match(/(增长|提高|上升|下降|降低).*?([0-9.]+)%/);
    
    if (valueMatch) {
      // 找出最匹配的指标
      let bestMatch = null;
      let maxScore = 0;
      
      for (const indicator of indicators) {
        // 计算匹配得分
        const score = indicator.keywords.reduce((sum, keyword) => 
          sum + (trimmedLine.includes(keyword) ? 1 : 0), 0);
          
        if (score > maxScore) {
          maxScore = score;
          bestMatch = indicator;
        }
      }
      
      // 如果找到匹配的指标，且该指标还没有添加过
      if (bestMatch && maxScore > 0 && !results.some(r => r.title === bestMatch.title)) {
        // 提取变化率和趋势
        let change = 0;
        let trend = 'up';
        
        if (changeMatch) {
          change = parseFloat(changeMatch[2]);
          // 判断趋势方向
          if (changeMatch[1].includes('下降') || changeMatch[1].includes('降低')) {
            trend = 'down';
            change = -change; // 负数表示下降
          }
        }
        
        // 添加到结果中
        results.push({
          id: results.length + 1,
          title: bestMatch.title,
          value: valueMatch[0],
          change: change,
          trend: trend,
          icon: bestMatch.icon,
          color: bestMatch.color
        });
      }
    }
  }
  
  // 如果找到的数据不足，使用默认数据补充
  if (results.length < 4) {
    // 查找哪些指标还没有数据
    const missingIndicators = indicators.filter(
      indicator => !results.some(r => r.title === indicator.title)
    );
    
    // 为缺失的指标添加默认数据
    for (const indicator of missingIndicators) {
      if (results.length >= 4) break;
      
      results.push({
        id: results.length + 1,
        title: indicator.title,
        value: indicator.title.includes('评分') ? '4.5/5' : '80%',
        change: Math.floor(Math.random() * 10 + 1) * (Math.random() > 0.3 ? 1 : -1),
        trend: Math.random() > 0.3 ? 'up' : 'down',
        icon: indicator.icon,
        color: indicator.color
      });
    }
  }
  
  return results;
}

/**
 * 生成模拟概览数据
 * @param {Object} params - 请求参数
 * @returns {Object} 模拟响应
 */
function mockOverviewData(params) {
  console.log('使用模拟概览数据');
  
  // 根据不同的时间范围返回略有差异的模拟数据
  let variationFactor = 1.0;
  
  if (params.timeRange === 'week') {
    variationFactor = 0.8;
  } else if (params.timeRange === 'month') {
    variationFactor = 0.9;
  } else if (params.timeRange === 'year') {
    variationFactor = 1.2;
  }
  
  return {
    status: 'success',
    message: '获取概览数据成功(模拟数据)',
    data: [
      {
        id: 1,
        title: '教学资源利用率',
        value: `${Math.round(78.5 * variationFactor)}%`,
        change: Math.round(15.2 * variationFactor * 10) / 10,
        trend: 'up',
        icon: '📚',
        color: '#1890ff'
      },
      {
        id: 2,
        title: '平均教学质量评分',
        value: `${(4.6 * Math.min(variationFactor, 1.08)).toFixed(1)}/5`,
        change: Math.round(10.3 * variationFactor * 10) / 10,
        trend: 'up',
        icon: '⭐',
        color: '#52c41a'
      },
      {
        id: 3,
        title: '学生参与度',
        value: `${Math.round(82 * variationFactor)}%`,
        change: Math.round(13.7 * variationFactor * 10) / 10,
        trend: 'up',
        icon: '👥',
        color: '#722ed1'
      },
      {
        id: 4,
        title: '教学资源缺口',
        value: `${Math.round(8 * (2 - variationFactor))}%`,
        change: Math.round(12.1 * variationFactor * 10) / 10,
        trend: 'down',
        icon: '📊',
        color: '#faad14'
      }
    ]
  };
}

/**
 * 带重试机制的Dify API调用函数
 * @param {Object} data - 请求数据
 * @param {number} maxRetries - 最大重试次数
 * @returns {Promise} 返回Dify API响应
 */
function callDifyAPIWithRetry(data, maxRetries = 1) {
  // 确保数据中包含intent参数
  if (!data.intent && (!data.inputs || !data.inputs.intent)) {
    // 默认设置为5(数据查询)
    data.intent = 5;
    if (data.inputs) {
      data.inputs.intent = 5;
    }
  }
  
  console.log(`调用Dify API (带重试机制，最大重试${maxRetries}次):`, data);
  
  return new Promise((resolve, reject) => {
    let retryCount = 0;
    
    function attemptCall() {
      callDifyAPI(data)
        .then(resolve)
        .catch(error => {
          console.error(`API调用失败 (尝试 ${retryCount + 1}/${maxRetries + 1}):`, error);
          
          if (retryCount < maxRetries) {
            retryCount++;
            console.log(`等待后重试 (${retryCount}/${maxRetries})...`);
            setTimeout(attemptCall, 1000 * retryCount); // 每次重试增加等待时间
          } else {
            reject(error);
          }
        });
    }
    
    attemptCall();
  });
} 